Enter 2006 September/Enter 09 2006.iso/Internet/SpamExperts Home 1.1/SpamExperts Home.exe/lib/spamexperts.modules/win32pdhutil.pyc

Python Compiled Bytecode | 2006-07-14 | 5.2 KB | 166 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)

'''Utilities for the win32 Performance Data Helper module

Example:
  To get a single bit of data:
  >>> import win32pdhutil
  >>> win32pdhutil.GetPerformanceAttributes("Memory", "Available Bytes")
  6053888
  >>> win32pdhutil.FindPerformanceAttributesByName("python", counter="Virtual Bytes")
  [22278144]

  First example returns data which is not associated with any specific instance.

  The second example reads data for a specific instance - hence the list return -
  it would return one result for each instance of Python running.

  In general, it can be tricky finding exactly the "name" of the data you wish to query.
  Although you can use <om win32pdh.EnumObjectItems>(None,None,(eg)"Memory", -1) to do this,
  the easiest way is often to simply use PerfMon to find out the names.
'''
import win32pdh
import string
import time
error = win32pdh.error
counter_english_map = { }

def find_pdh_counter_localized_name(english_name, machine_name = None):
    if not counter_english_map:
        import win32api
        import win32con
        counter_reg_value = win32api.RegQueryValueEx(win32con.HKEY_PERFORMANCE_DATA, 'Counter 009')
        counter_list = counter_reg_value[0]
        for i in range(0, len(counter_list) - 1, 2):

            try:
                counter_id = int(counter_list[i])
            except ValueError:
                continue

            counter_english_map[counter_list[i + 1].lower()] = counter_id


    return win32pdh.LookupPerfNameByIndex(machine_name, counter_english_map[english_name.lower()])


def GetPerformanceAttributes(object, counter, instance = None, inum = -1, format = win32pdh.PDH_FMT_LONG, machine = None):
    path = win32pdh.MakeCounterPath((machine, object, instance, None, inum, counter))
    hq = win32pdh.OpenQuery()

    try:
        hc = win32pdh.AddCounter(hq, path)

        try:
            win32pdh.CollectQueryData(hq)
            (type, val) = win32pdh.GetFormattedCounterValue(hc, format)
            return val
        finally:
            win32pdh.RemoveCounter(hc)

    finally:
        win32pdh.CloseQuery(hq)



def FindPerformanceAttributesByName(instanceName, object = None, counter = None, format = win32pdh.PDH_FMT_LONG, machine = None, bRefresh = 0):
    '''Find peformance attributes by (case insensitive) instance name.
\t
\tGiven a process name, return a list with the requested attributes.
\tMost useful for returning a tuple of PIDs given a process name.
\t'''
    if object is None:
        object = find_pdh_counter_localized_name('Process', machine)

    if counter is None:
        counter = find_pdh_counter_localized_name('ID Process', machine)

    if bRefresh:
        win32pdh.EnumObjects(None, machine, 0, 1)

    instanceName = string.lower(instanceName)
    (items, instances) = win32pdh.EnumObjectItems(None, None, object, -1)
    instance_dict = { }
    for instance in instances:

        try:
            instance_dict[instance] = instance_dict[instance] + 1
        continue
        except KeyError:
            instance_dict[instance] = 0
            continue



    ret = []
    for instance, max_instances in instance_dict.items():
        for inum in xrange(max_instances + 1):
            if string.lower(instance) == instanceName:
                ret.append(GetPerformanceAttributes(object, counter, instance, inum, format, machine))
                continue
            None<EXCEPTION MATCH>KeyError


    return ret


def ShowAllProcesses():
    object = 'Process'
    (items, instances) = win32pdh.EnumObjectItems(None, None, object, win32pdh.PERF_DETAIL_WIZARD)
    instance_dict = { }
    for instance in instances:

        try:
            instance_dict[instance] = instance_dict[instance] + 1
        continue
        except KeyError:
            instance_dict[instance] = 0
            continue



    items = [
        'ID Process'] + items[:5]
    print 'Process Name', string.join(items, ',')
    for instance, max_instances in instance_dict.items():
        for inum in xrange(max_instances + 1):
            hq = win32pdh.OpenQuery()
            hcs = []
            for item in items:
                path = win32pdh.MakeCounterPath((None, object, instance, None, inum, item))
                hcs.append(win32pdh.AddCounter(hq, path))

            win32pdh.CollectQueryData(hq)
            time.sleep(0.01)
            win32pdh.CollectQueryData(hq)
            print '%-15s\t' % instance[:15],
            for hc in hcs:
                (type, val) = win32pdh.GetFormattedCounterValue(hc, win32pdh.PDH_FMT_LONG)
                print '%5d' % val,
                win32pdh.RemoveCounter(hc)

            print
            win32pdh.CloseQuery(hq)




def BrowseCallBackDemo(counter):
    (machine, object, instance, parentInstance, index, counterName) = win32pdh.ParseCounterPath(counter)
    result = GetPerformanceAttributes(object, counterName, instance, index, win32pdh.PDH_FMT_DOUBLE, machine)
    print "Value of '%s' is" % counter, result
    print "Added '%s' on object '%s' (machine %s), instance %s(%d)-parent of %s" % (counterName, object, machine, instance, index, parentInstance)


def browse(callback = BrowseCallBackDemo, title = 'Python Browser', level = win32pdh.PERF_DETAIL_WIZARD):
    win32pdh.BrowseCounters(None, 0, callback, level, title)

if __name__ == '__main__':
    ShowAllProcesses()
    print 'Virtual Bytes = ', FindPerformanceAttributesByName('python', counter = 'Virtual Bytes')
    print 'Available Bytes = ', GetPerformanceAttributes('Memory', 'Available Bytes')
    print 'Browsing for counters...'
    browse()